"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
// 使用ES模块导入方式
const electron_1 = require("electron");
const path = __importStar(require("path"));
const fs = __importStar(require("fs"));
const serialport_1 = require("serialport");
const parser_readline_1 = require("@serialport/parser-readline");
// 存储串口实例
let port = null;
let parser = null;
// 存储串口数据回调
// 暂时保留回调机制，以备后续功能扩展
// 添加调试日志
console.log('Electron主进程启动中...');
console.log('当前目录:', __dirname);
// 确保应用只运行一个实例
const gotTheLock = electron_1.app.requestSingleInstanceLock();
if (!gotTheLock) {
    electron_1.app.quit();
}
else {
    electron_1.app.on('second-instance', () => {
        // 当用户尝试打开第二个实例时，聚焦到现有的窗口
        if (global.mainWindow) {
            if (global.mainWindow.isMinimized())
                global.mainWindow.restore();
            global.mainWindow.focus();
        }
    });
}
global.mainWindow = null;
// 创建浏览器窗口的函数
function createWindow() {
    // 使用内联的preload脚本，而不是外部文件
    console.log('使用内联preload脚本...');
    // 创建主窗口
    global.mainWindow = new electron_1.BrowserWindow({
        width: 800,
        height: 600,
        minWidth: 800,
        minHeight: 600,
        webPreferences: {
            preload: path.join(__dirname, 'preload.js'),
            nodeIntegration: false,
            contextIsolation: true,
            devTools: true, // 确保DevTools开启
        },
    });
    // 输出 preload 路径以便调试（确保 preload 文件在运行时可用）
    try {
        const preloadPath = path.join(__dirname, 'preload.js');
        console.log('预加载脚本预期路径:', preloadPath);
        console.log('预加载脚本是否存在:', fs.existsSync(preloadPath));
    }
    catch (err) {
        console.error('检查 preload 路径时出错:', err);
    }
    // 页面加载完成的简单日志 — 所有渲染可用 API 已通过 preload.js 暴露
    global.mainWindow.webContents.on('did-finish-load', () => {
        console.log('页面加载完成 — 使用 preload 暴露的 electronAPI');
    });
    // 自动打开DevTools
    global.mainWindow.webContents.openDevTools();
    console.log('DevTools已打开');
    // 在开发模式下加载Vite服务器的URL
    // 在生产模式下加载打包后的HTML文件
    if (global.mainWindow) {
        // 使用process.argv来判断是否是开发模式，更加可靠
        const isDev = process.argv.includes('--dev');
        if (isDev) {
            global.mainWindow.loadURL('http://localhost:5173');
            // 开发模式下打开开发者工具
            global.mainWindow.webContents.openDevTools();
        }
        else {
            global.mainWindow.loadFile(path.join(__dirname, '../../dist/index.html'));
        }
        // 当窗口关闭时
        global.mainWindow.on('closed', () => {
            global.mainWindow = null;
        });
    }
}
// 当Electron完成初始化后创建窗口
electron_1.app.whenReady().then(() => {
    createWindow();
    // 在macOS上，当点击dock图标并且没有其他窗口打开时，重新创建一个窗口
    electron_1.app.on('activate', () => {
        if (require('electron').BrowserWindow.getAllWindows().length === 0)
            createWindow();
    });
});
// 当所有窗口关闭时退出应用（Windows和Linux）
electron_1.app.on('window-all-closed', () => {
    if (process.platform !== 'darwin') {
        electron_1.app.quit();
    }
});
// 设置IPC通信处理器
// 处理获取串口列表请求
electron_1.ipcMain.handle('list-serial-ports', async () => {
    try {
        console.log('正在获取可用串口列表...');
        const ports = await serialport_1.SerialPort.list();
        console.log('发现串口:', ports.map((p) => p.path));
        return ports.map((p) => ({
            path: p.path,
            manufacturer: p.manufacturer || '未知',
            serialNumber: p.serialNumber || '',
            pnpId: p.pnpId || '',
            locationId: p.locationId || '',
            vendorId: p.vendorId || '',
            productId: p.productId || ''
        }));
    }
    catch (error) {
        console.error('获取串口列表失败:', error);
        return [];
    }
});
// 处理打开串口请求
electron_1.ipcMain.handle('open-serial-port', async (_event, params) => {
    try {
        const { port: portPath, baudRate } = params;
        console.log(`尝试打开串口: ${portPath}, 波特率: ${baudRate}`);
        // 如果已打开串口，先关闭
        if (port && port.isOpen) {
            await port.close();
            port = null;
            parser = null;
        }
        // 修复SerialPort构造函数参数
        port = new serialport_1.SerialPort({
            path: portPath,
            baudRate: parseInt(baudRate.toString()),
            autoOpen: false
        });
        // 设置Readline解析器
        parser = port.pipe(new parser_readline_1.ReadlineParser({ delimiter: '\n' }));
        // 打开串口
        await new Promise((resolve, reject) => {
            port.open((err) => {
                if (err) {
                    reject(err);
                }
                else {
                    resolve();
                }
            });
        });
        console.log(`串口 ${portPath} 已成功打开`);
        // 监听数据事件
        parser.on('data', (data) => {
            console.log(`收到串口数据: ${data}`);
            // 通过IPC发送数据到渲染进程
            global.mainWindow?.webContents.send('serial-data', data);
        });
        // 监听错误事件
        port.on('error', (error) => {
            console.error('串口错误:', error);
            global.mainWindow?.webContents.send('serial-error', error.message);
        });
        return { success: true, message: `串口 ${portPath} 已成功打开` };
    }
    catch (error) {
        console.error('打开串口失败:', error);
        return { success: false, error: error.message };
    }
});
// 处理关闭串口请求
electron_1.ipcMain.handle('close-serial-port', async () => {
    try {
        if (port && port.isOpen) {
            await port.close();
            port = null;
            parser = null;
            console.log('串口已成功关闭');
            return { success: true, message: '串口已成功关闭' };
        }
        else {
            return { success: true, message: '串口未打开' };
        }
    }
    catch (error) {
        console.error('关闭串口失败:', error);
        return { success: false, error: error.message };
    }
});
// 处理发送数据请求
electron_1.ipcMain.handle('send-data', async (_event, params) => {
    try {
        if (!port || !port.isOpen) {
            throw new Error('串口未打开');
        }
        const { data } = params;
        console.log(`发送数据: ${data}`);
        await new Promise((resolve, reject) => {
            port.write(data, (err) => {
                if (err) {
                    reject(err);
                }
                else {
                    resolve();
                }
            });
        });
        return { success: true, message: '数据发送成功' };
    }
    catch (error) {
        console.error('发送数据失败:', error);
        return { success: false, error: error.message };
    }
});
// 处理内部API调用
electron_1.ipcMain.handle('electron-api-call', async (_event, message) => {
    try {
        console.log('收到electron-api-call:', message);
        const channel = message.channel;
        const requestId = message.requestId;
        const args = message.args || [];
        // 直接调用对应的处理逻辑，不使用不存在的handleSync
        if (channel === 'list-serial-ports') {
            // 直接获取串口列表
            const ports = await serialport_1.SerialPort.list();
            const result = ports.map((p) => ({
                path: p.path,
                manufacturer: p.manufacturer || '未知',
                serialNumber: p.serialNumber || '',
                pnpId: p.pnpId || '',
                locationId: p.locationId || '',
                vendorId: p.vendorId || '',
                productId: p.productId || ''
            }));
            return { requestId, result };
        }
        else if (channel === 'open-serial-port' && args.length > 0) {
            // 直接打开串口
            const params = args[0];
            const portPath = params.port || params.portPath;
            const baudRate = params.baudRate;
            if (!portPath || !baudRate) {
                return { requestId, result: { success: false, error: '缺少必要参数' } };
            }
            // 实现打开串口逻辑
            try {
                // 如果已打开串口，先关闭
                if (port && port.isOpen) {
                    await port.close();
                    port = null;
                    parser = null;
                }
                port = new serialport_1.SerialPort({
                    path: portPath,
                    baudRate: parseInt(baudRate.toString()),
                    autoOpen: false
                });
                // 设置Readline解析器
                parser = port.pipe(new parser_readline_1.ReadlineParser({ delimiter: '\n' }));
                // 打开串口
                await new Promise((resolve, reject) => {
                    port.open((err) => {
                        if (err) {
                            reject(err);
                        }
                        else {
                            resolve();
                        }
                    });
                });
                // 监听数据事件
                parser.on('data', (data) => {
                    if (global.mainWindow) {
                        global.mainWindow.webContents.send('serial-data', data);
                    }
                });
                // 监听错误事件
                port.on('error', (error) => {
                    if (global.mainWindow) {
                        global.mainWindow.webContents.send('serial-error', error.message);
                    }
                });
                return { requestId, result: { success: true, message: '串口已成功打开' } };
            }
            catch (error) {
                return { requestId, result: { success: false, error: error.message } };
            }
        }
        else if (channel === 'close-serial-port') {
            // 直接关闭串口
            try {
                if (port && port.isOpen) {
                    await port.close();
                    port = null;
                    parser = null;
                    return { requestId, result: { success: true, message: '串口已成功关闭' } };
                }
                else {
                    return { requestId, result: { success: true, message: '串口未打开' } };
                }
            }
            catch (error) {
                return { requestId, result: { success: false, error: error.message } };
            }
        }
        else if (channel === 'send-data' && args.length > 0) {
            // 直接发送数据
            try {
                if (!port || !port.isOpen) {
                    return { requestId, result: { success: false, error: '串口未打开' } };
                }
                const params = args[0];
                const data = params.data || params;
                await new Promise((resolve, reject) => {
                    port.write(data, (err) => {
                        if (err) {
                            reject(err);
                        }
                        else {
                            resolve();
                        }
                    });
                });
                return { requestId, result: { success: true, message: '数据发送成功' } };
            }
            catch (error) {
                return { requestId, result: { success: false, error: error.message } };
            }
        }
        return { requestId, result: { success: false, error: '未知的通道' } };
    }
    catch (error) {
        console.error('处理electron-api-call失败:', error);
        return { requestId: message?.requestId || '', result: { success: false, error: error.message } };
    }
});
